// pages/add-bank-card/add-bank-card.ts
import { BankCardAPI } from '../../utils/profile-api';
import { CloudConfig, OCRConfig } from '../../utils/cloud-config';
import { UploadAPI } from '../../utils/api';

interface BankInfo {
  name: string;
  code: string;
}

interface FormData {
  cardNumber: string;
  cardHolderName: string;
  cardHolderIdcard: string;      // 持卡人身份证号
  cardHolderPhone: string;       // 持卡人预留手机号
  bankName: string;
  bankCode?: string;
  branchName?: string;           // 开户支行名称
  cardType: number;              // 1-借记卡，2-贷记卡，3-对公账户
  expiry?: string;
  setAsDefault: boolean;
}

// 百度OCR token缓存（全局变量）
let baiduAccessTokenCache: { token: string; expireAt: number } = { token: '', expireAt: 0 };

Page({
  data: {
    statusBarHeight: 0,
    contentPaddingTop: 0,
    cardImage: '',
    recognizing: false,
    idCardImage: '',
    recognizingIdCard: false,
    submitting: false,
    bankIndex: -1,
    bankList: [
      { name: '中国工商银行', code: 'ICBC' },
      { name: '中国建设银行', code: 'CCB' },
      { name: '中国银行', code: 'BOC' },
      { name: '中国农业银行', code: 'ABC' },
      { name: '交通银行', code: 'BOCOM' },
      { name: '招商银行', code: 'CMB' },
      { name: '浦发银行', code: 'SPDB' },
      { name: '中信银行', code: 'CITIC' },
      { name: '光大银行', code: 'CEB' },
      { name: '华夏银行', code: 'HXB' },
      { name: '民生银行', code: 'CMBC' },
      { name: '广发银行', code: 'GDB' },
      { name: '平安银行', code: 'PAB' },
      { name: '兴业银行', code: 'CIB' },
      { name: '邮储银行', code: 'PSBC' },
      { name: '其他银行', code: 'OTHER' }
    ] as BankInfo[],
    formData: {
      cardNumber: '',
      cardHolderName: '',
      cardHolderIdcard: '',
      cardHolderPhone: '',
      bankName: '',
      bankCode: '',
      branchName: '',
      cardType: 1,
      expiry: '',
      setAsDefault: false
    } as FormData
  },

  onLoad() {
    // 获取状态栏高度
    try {
      const systemInfo = wx.getSystemInfoSync();
      const statusBarHeight = systemInfo.statusBarHeight || 0;
      const navBarHeight = 88; // 导航栏高度（rpx转px约88px）
      this.setData({
        statusBarHeight,
        contentPaddingTop: statusBarHeight + navBarHeight
      });
    } catch (error) {
      console.error('获取系统信息失败:', error);
      this.setData({
        statusBarHeight: 44,
        contentPaddingTop: 132
      });
    }
  },

  goBack() {
    wx.navigateBack();
  },

  // 选择银行卡图片
  chooseCardImage() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        this.setData({
          cardImage: tempFilePath
        });
      },
      fail: (err) => {
        // 用户取消选择图片时不显示错误提示
        if (err.errMsg && err.errMsg.includes('cancel')) {
          console.log('用户取消选择图片');
          return;
        }
        console.error('选择图片失败:', err);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },

  // 移除银行卡图片
  removeCardImage() {
    this.setData({
      cardImage: ''
    });
  },

  // 选择身份证图片
  chooseIdCardImage() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        this.setData({
          idCardImage: tempFilePath
        });
      },
      fail: (err) => {
        // 用户取消选择图片时不显示错误提示
        if (err.errMsg && err.errMsg.includes('cancel')) {
          console.log('用户取消选择身份证图片');
          return;
        }
        console.error('选择身份证图片失败:', err);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },

  // 移除身份证图片
  removeIdCardImage() {
    this.setData({
      idCardImage: ''
    });
  },

  // OCR识别银行卡号（纯前端实现，无需后端）
  async recognizeCard() {
    if (!this.data.cardImage) {
      wx.showToast({
        title: '请先选择银行卡图片',
        icon: 'none'
      });
      return;
    }

    this.setData({ recognizing: true });

    try {
      let result = null;
      
      // 优先使用百度OCR（纯前端实现，推荐方案，所有人都可以直接使用）
      if (OCRConfig.useBaiduOCR) {
        try {
          result = await this.recognizeWithBaiduOCR(this.data.cardImage);
        } catch (baiduError: any) {
          console.warn('百度OCR失败，尝试后端API:', baiduError);
          
          // 如果百度OCR失败，尝试后端API
          try {
            result = await this.recognizeWithBackendAPI(this.data.cardImage);
          } catch (backendError: any) {
            console.warn('后端OCR也失败，尝试云开发OCR（降级方案）:', backendError);
            
            // 如果后端API也失败，且启用了云开发OCR，则尝试云开发方案作为降级
            if (OCRConfig.cloudOCR.enabled) {
              try {
                result = await this.recognizeWithCloudOCR(this.data.cardImage);
              } catch (cloudError: any) {
                console.warn('所有OCR方案都失败:', cloudError);
                throw new Error('识别服务暂时不可用，请手动输入银行卡信息');
              }
            } else {
              throw baiduError; // 抛出百度OCR的错误，因为它是首选方案
            }
          }
        }
      } else {
        // 百度OCR未启用，尝试后端API
        try {
          result = await this.recognizeWithBackendAPI(this.data.cardImage);
        } catch (backendError: any) {
          // 如果后端API失败，且启用了云开发OCR，则尝试云开发方案
          if (OCRConfig.cloudOCR.enabled) {
            try {
              result = await this.recognizeWithCloudOCR(this.data.cardImage);
            } catch (cloudError: any) {
              throw new Error('识别服务暂时不可用，请手动输入银行卡信息');
            }
          } else {
            throw backendError;
          }
        }
      }
      
      // 方案2：如果云开发不可用，可以尝试使用第三方OCR服务的前端SDK
      // const result = await this.recognizeWithThirdPartyOCR(this.data.cardImage);
      
      if (result) {
        const { cardNumber, bankName, bankCode } = result;
        
        // 自动填充表单
        let bankIndex = -1;
        if (bankName) {
          bankIndex = this.data.bankList.findIndex(bank => 
            bank.name.includes(bankName) || bankName.includes(bank.name)
          );
        }

        this.setData({
          'formData.cardNumber': cardNumber || '',
          'formData.bankName': bankName || '',
          'formData.bankCode': bankCode || '',
          bankIndex: bankIndex >= 0 ? bankIndex : -1
        });

        wx.showToast({
          title: '识别成功',
          icon: 'success'
        });
      } else {
        throw new Error('识别失败，请手动输入');
      }
    } catch (error: any) {
      console.error('OCR识别失败:', error);
      
      // 提供友好的错误提示
      let errorMessage = '识别失败，请手动输入';
      if (error.message) {
        errorMessage = error.message;
      } else if (error.msg) {
        errorMessage = error.msg;
      } else if (error.errMsg) {
        errorMessage = error.errMsg;
      }
      
      // 不显示弹窗，直接显示toast，让用户可以选择手动输入
      wx.showToast({
        title: errorMessage,
        icon: 'none',
        duration: 2000
      });
    } finally {
      this.setData({ recognizing: false });
      wx.hideLoading();
    }
  },

  // 方案1：使用百度OCR（纯前端实现，推荐方案，所有人都可以直接使用）
  // 需要在 utils/cloud-config.ts 中配置百度OCR的API Key和Secret Key
  async recognizeWithBaiduOCR(filePath: string): Promise<any> {
    const { apiKey, secretKey } = OCRConfig.baiduOCR;
    
    // 验证密钥配置
    if (!apiKey || !secretKey || apiKey.trim() === '' || secretKey.trim() === '') {
      throw new Error('百度OCR密钥未配置，请在 utils/cloud-config.ts 中配置API Key和Secret Key');
    }

    // 验证密钥格式（API Key通常是24位字符）
    const trimmedApiKey = apiKey.trim();
    const trimmedSecretKey = secretKey.trim();
    
    console.log('使用百度OCR识别');
    console.log('API Key长度:', trimmedApiKey.length, '前5位:', trimmedApiKey.substring(0, 5));
    console.log('Secret Key长度:', trimmedSecretKey.length, '前5位:', trimmedSecretKey.substring(0, 5));
    
    // 检查密钥长度是否合理（API Key通常是24位，Secret Key通常是32位）
    if (trimmedApiKey.length < 20 || trimmedSecretKey.length < 20) {
      console.warn('警告：API Key或Secret Key长度异常，可能不正确');
    }
    
    wx.showLoading({ title: '识别中...', mask: true });

    try {
      // 1. 读取图片文件并转换为base64
      const imageBase64 = await this.fileToBase64(filePath);
      
      // 2. 获取百度OCR的access_token（使用trim后的密钥）
      const accessToken = await this.getBaiduAccessToken(apiKey.trim(), secretKey.trim());
      
      // 3. 调用百度OCR接口进行识别
      const ocrResult = await this.callBaiduOCR(accessToken, imageBase64);
      
      // 4. 解析识别结果
      const result = ocrResult.result || {};
      const bankName = result.bank_name || '';
      
      return {
        cardNumber: (result.bank_card_number || '').replace(/\s/g, ''), // 移除空格
        bankName: bankName,
        bankCode: this.parseBankCode(bankName)
      };
    } catch (error: any) {
      console.error('百度OCR识别失败:', error);
      throw error;
    } finally {
      wx.hideLoading();
    }
  },

  // 读取文件并转换为base64
  fileToBase64(filePath: string): Promise<string> {
    return new Promise((resolve, reject) => {
      const fs = wx.getFileSystemManager();
      fs.readFile({
        filePath: filePath,
        encoding: 'base64',
        success: (res: any) => {
          resolve(res.data);
        },
        fail: (err: any) => {
          reject(new Error('读取图片文件失败：' + (err.errMsg || '未知错误')));
        }
      });
    });
  },

  // 获取百度OCR的access_token（带缓存）
  async getBaiduAccessToken(apiKey: string, secretKey: string): Promise<string> {
    const now = Date.now();
    
    // 检查缓存的token是否还有效（提前60秒刷新）
    if (baiduAccessTokenCache.token && now < baiduAccessTokenCache.expireAt - 60000) {
      return baiduAccessTokenCache.token;
    }

    // 验证密钥是否为空
    const trimmedApiKey = apiKey ? apiKey.trim() : '';
    const trimmedSecretKey = secretKey ? secretKey.trim() : '';
    
    if (!trimmedApiKey || !trimmedSecretKey) {
      return Promise.reject(new Error('百度OCR密钥未配置或为空，请在 utils/cloud-config.ts 中配置密钥'));
    }

    // 百度OAuth 2.0 token接口需要使用POST方式，参数在body中
    // 微信小程序wx.request会自动将data对象转换为URL编码格式
    const url = 'https://aip.baidubce.com/oauth/2.0/token';

    console.log('请求百度OCR token');
    console.log('API Key（完整）:', trimmedApiKey);
    console.log('API Key长度:', trimmedApiKey.length);
    console.log('Secret Key长度:', trimmedSecretKey.length);
    console.log('请确认：');
    console.log('1. API Key是否正确（从百度控制台复制）');
    console.log('2. 是否在银行卡识别服务中授权了该应用');

    return new Promise((resolve, reject) => {
      wx.request({
        url: url,
        method: 'POST',
        header: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        data: {
          grant_type: 'client_credentials',
          client_id: trimmedApiKey,
          client_secret: trimmedSecretKey
        },
        success: (res: any) => {
          console.log('百度OCR token完整响应:', JSON.stringify(res, null, 2));
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);
          
          if (res.statusCode === 200 && res.data) {
            if (res.data.access_token) {
              // 缓存token
              baiduAccessTokenCache.token = res.data.access_token;
              baiduAccessTokenCache.expireAt = now + (res.data.expires_in || 2592000) * 1000;
              resolve(res.data.access_token);
            } else if (res.data.error || res.data.error_description) {
              // 处理错误响应
              const errorMsg = res.data.error_description || res.data.error || '未知错误';
              reject(new Error('获取百度OCR token失败：' + errorMsg + '，请检查API Key和Secret Key是否正确'));
            } else {
              reject(new Error('获取百度OCR token失败：响应格式错误，响应数据：' + JSON.stringify(res.data)));
            }
          } else if (res.statusCode === 401) {
            // 401错误通常是密钥问题
            const errorDetail = res.data ? JSON.stringify(res.data) : '无详细错误信息';
            reject(new Error('获取百度OCR token失败：API Key或Secret Key不正确（401错误）\n响应详情：' + errorDetail + '\n\n请检查：\n1. API Key和Secret Key是否正确\n2. 是否在百度AI控制台开通了银行卡识别服务\n3. 密钥是否需要等待几分钟生效'));
          } else {
            const errorDetail = res.data ? JSON.stringify(res.data) : '无详细错误信息';
            reject(new Error('获取百度OCR token失败：HTTP状态码 ' + res.statusCode + '，响应详情：' + errorDetail));
          }
        },
        fail: (err: any) => {
          console.error('百度OCR token请求失败:', err);
          reject(new Error('获取百度OCR token失败：' + (err.errMsg || '网络错误')));
        }
      });
    });
  },

  // 调用百度OCR接口（银行卡）
  async callBaiduOCR(accessToken: string, imageBase64: string): Promise<any> {
    return new Promise((resolve, reject) => {
      wx.request({
        url: `https://aip.baidubce.com/rest/2.0/ocr/v1/bankcard?access_token=${accessToken}`,
        method: 'POST',
        header: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        data: {
          image: imageBase64
        },
        success: (res: any) => {
          if (res.statusCode === 200) {
            if (res.data.error_code) {
              reject(new Error(`百度OCR识别失败：${res.data.error_code} - ${res.data.error_msg || '未知错误'}`));
            } else if (res.data.result) {
              resolve(res.data);
            } else {
              reject(new Error('百度OCR返回数据格式错误'));
            }
          } else {
            reject(new Error('百度OCR请求失败，状态码：' + res.statusCode));
          }
        },
        fail: (err: any) => {
          reject(new Error('百度OCR请求失败：' + (err.errMsg || '网络错误')));
        }
      });
    });
  },

  // 调用百度OCR接口（身份证）
  async callBaiduIdCardOCR(accessToken: string, imageBase64: string, side: 'front' | 'back' = 'front'): Promise<any> {
    return new Promise((resolve, reject) => {
      wx.request({
        url: `https://aip.baidubce.com/rest/2.0/ocr/v1/idcard?access_token=${accessToken}`,
        method: 'POST',
        header: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        data: {
          image: imageBase64,
          id_card_side: side
        },
        success: (res: any) => {
          if (res.statusCode === 200) {
            if (res.data.error_code) {
              reject(new Error(`百度OCR识别失败：${res.data.error_code} - ${res.data.error_msg || '未知错误'}`));
            } else if (res.data.words_result) {
              resolve(res.data);
            } else {
              reject(new Error('百度OCR返回数据格式错误'));
            }
          } else {
            reject(new Error('百度OCR请求失败，状态码：' + res.statusCode));
          }
        },
        fail: (err: any) => {
          reject(new Error('百度OCR请求失败：' + (err.errMsg || '网络错误')));
        }
      });
    });
  },

  // 解析银行编码
  parseBankCode(bankName: string): string {
    if (!bankName) return 'OTHER';
    
    const bankCodeMap: Record<string, string> = {
      '中国工商银行': 'ICBC',
      '工商银行': 'ICBC',
      '中国建设银行': 'CCB',
      '建设银行': 'CCB',
      '中国银行': 'BOC',
      '农业银行': 'ABC',
      '中国农业银行': 'ABC',
      '交通银行': 'BOCOM',
      '招商银行': 'CMB',
      '浦发银行': 'SPDB',
      '中信银行': 'CITIC',
      '光大银行': 'CEB',
      '华夏银行': 'HXB',
      '民生银行': 'CMBC',
      '广发银行': 'GDB',
      '平安银行': 'PAB',
      '兴业银行': 'CIB',
      '邮储银行': 'PSBC',
      '中国邮政储蓄银行': 'PSBC'
    };

    for (const [name, code] of Object.entries(bankCodeMap)) {
      if (bankName.includes(name) || name.includes(bankName)) {
        return code;
      }
    }
    
    return 'OTHER';
  },

  /**
   * OCR识别身份证（纯前端实现，使用百度OCR）
   */
  async recognizeIdCard() {
    if (!this.data.idCardImage) {
      wx.showToast({
        title: '请先选择身份证图片',
        icon: 'none'
      });
      return;
    }

    this.setData({ recognizingIdCard: true });
    wx.showLoading({ title: '识别中...', mask: true });

    try {
      let result = null;
      
      // 优先使用百度OCR（纯前端实现，推荐方案）
      if (OCRConfig.useBaiduOCR) {
        try {
          result = await this.recognizeIdCardWithBaiduOCR(this.data.idCardImage);
        } catch (baiduError: any) {
          console.warn('百度OCR识别身份证失败:', baiduError);
          throw baiduError;
        }
      } else {
        throw new Error('请启用百度OCR功能');
      }
      
      if (result) {
        const { idCardNumber, name } = result;
        
        // 自动填充表单
        this.setData({
          'formData.cardHolderIdcard': idCardNumber || '',
          'formData.cardHolderName': name || this.data.formData.cardHolderName || ''
        });

        wx.showToast({
          title: '识别成功',
          icon: 'success'
        });
      } else {
        throw new Error('识别失败，请手动输入');
      }
    } catch (error: any) {
      console.error('OCR识别身份证失败:', error);
      
      let errorMessage = '识别失败，请手动输入';
      if (error.message) {
        errorMessage = error.message;
      } else if (error.msg) {
        errorMessage = error.msg;
      } else if (error.errMsg) {
        errorMessage = error.errMsg;
      }
      
      wx.showToast({
        title: errorMessage,
        icon: 'none',
        duration: 2000
      });
    } finally {
      this.setData({ recognizingIdCard: false });
      wx.hideLoading();
    }
  },

  /**
   * 使用百度OCR识别身份证
   */
  async recognizeIdCardWithBaiduOCR(filePath: string): Promise<any> {
    const { apiKey, secretKey } = OCRConfig.baiduOCR;
    
    // 验证密钥配置
    if (!apiKey || !secretKey || apiKey.trim() === '' || secretKey.trim() === '') {
      throw new Error('百度OCR密钥未配置，请在 utils/cloud-config.ts 中配置API Key和Secret Key');
    }

    const trimmedApiKey = apiKey.trim();
    const trimmedSecretKey = secretKey.trim();
    
    console.log('使用百度OCR识别身份证');
    
    wx.showLoading({ title: '识别中...', mask: true });

    try {
      // 1. 读取图片文件并转换为base64
      const imageBase64 = await this.fileToBase64(filePath);
      
      // 2. 获取百度OCR的access_token
      const accessToken = await this.getBaiduAccessToken(trimmedApiKey, trimmedSecretKey);
      
      // 3. 调用百度OCR接口进行识别（识别正面）
      const ocrResult = await this.callBaiduIdCardOCR(accessToken, imageBase64, 'front');
      
      // 4. 解析识别结果
      // 百度OCR身份证识别返回格式：
      // words_result: {
      //   "姓名": { words: "张三" },
      //   "公民身份号码": { words: "110101199001011234" },
      //   ...
      // }
      const wordsResult = ocrResult.words_result || {};
      
      // 尝试多种可能的字段名
      const idCardNumber = 
        wordsResult['公民身份号码']?.words || 
        wordsResult['身份证号']?.words || 
        wordsResult['id_number']?.words || 
        wordsResult['IDNumber']?.words || 
        '';
      
      const name = 
        wordsResult['姓名']?.words || 
        wordsResult['name']?.words || 
        wordsResult['Name']?.words || 
        '';
      
      return {
        idCardNumber: idCardNumber.replace(/\s/g, '').replace(/[Xx]/g, 'X'), // 移除空格，统一X为大写
        name: name.trim()
      };
    } catch (error: any) {
      console.error('百度OCR识别身份证失败:', error);
      throw error;
    } finally {
      wx.hideLoading();
    }
  },

  // 方案2：使用后端API OCR（备用方案）
  // 不需要任何额外配置，直接调用后端接口即可
  async recognizeWithBackendAPI(filePath: string): Promise<any> {
    // 1. 先上传图片到后端服务器
    wx.showLoading({ title: '上传图片中...', mask: true });
    
    try {
      const uploadRes = await UploadAPI.uploadFile(filePath);
      console.log('银行卡图片上传响应:', uploadRes);
      // 后端返回格式: { code: 200, msg: "操作成功", data: "https://xxx.com/xxx.png" }
      let imageUrl = '';
      if (uploadRes?.data) {
        if (typeof uploadRes.data === 'string') {
          imageUrl = uploadRes.data;
        } else if (uploadRes.data.url) {
          imageUrl = uploadRes.data.url;
        } else if (uploadRes.data.fileUrl) {
          imageUrl = uploadRes.data.fileUrl;
        }
      }
      if (!imageUrl) {
        imageUrl = uploadRes?.url || '';
      }
      console.log('银行卡图片最终URL:', imageUrl);
      
      if (!imageUrl) {
        throw new Error('图片上传失败，未获取到图片地址');
      }
      
      wx.hideLoading();
      wx.showLoading({ title: '识别中...', mask: true });
      
      // 2. 调用后端OCR接口进行识别
      const ocrRes = await BankCardAPI.recognizeBankCard(imageUrl);
      
      if (ocrRes && ocrRes.code === 200 && ocrRes.data) {
        return ocrRes.data;
      } else {
        throw new Error(ocrRes?.msg || '识别失败，请重试');
      }
    } catch (error: any) {
      wx.hideLoading();
      console.error('后端OCR识别失败:', error);
      
      // 提供友好的错误信息
      let errorMsg = '识别失败，请手动输入';
      if (error.message) {
        errorMsg = error.message;
      } else if (error.msg) {
        errorMsg = error.msg;
      } else if (error.errMsg) {
        errorMsg = error.errMsg;
      }
      
      throw new Error(errorMsg);
    }
  },

  // 方案3：使用微信云开发OCR（备用方案，需要用户配置云开发环境）
  // 注意：需要在小程序后台开通云开发，并创建云函数
  async recognizeWithCloudOCR(filePath: string): Promise<any> {
    return new Promise((resolve, reject) => {
      // 检查是否已初始化云开发
      if (!wx.cloud) {
        reject(new Error('请先在小程序后台开通云开发功能，并在 utils/cloud-config.ts 中配置环境ID'));
        return;
      }

      // 1. 先上传图片到云存储
      const cloudPath = `bankcards/${Date.now()}-${Math.random().toString(36).substr(2, 9)}.jpg`;
      
      wx.cloud.uploadFile({
        cloudPath: cloudPath,
        filePath: filePath,
        success: (uploadRes) => {
          console.log('图片上传成功:', uploadRes);
          
          // 2. 调用云函数进行OCR识别
          wx.cloud.callFunction({
            name: OCRConfig.cloudOCR.functionName,
            data: {
              fileID: uploadRes.fileID
            },
            success: (res: any) => {
              console.log('OCR识别成功:', res);
              if (res.result && res.result.code === 200) {
                resolve(res.result.data);
              } else {
                reject(new Error(res.result?.msg || '识别失败'));
              }
            },
            fail: (err: any) => {
              console.error('OCR识别失败:', err);
              
              let errorMsg = '识别服务不可用';
              
              // 根据错误类型提供不同的提示
              if (err.errCode === -601034 || 
                  (err.errMsg && err.errMsg.includes('没有权限')) ||
                  (err.errMsg && err.errMsg.includes('开通云开发'))) {
                errorMsg = '请先在微信小程序后台开通云开发，并在 utils/cloud-config.ts 中配置环境ID';
              } else if (err.errMsg && err.errMsg.includes('not found')) {
                errorMsg = `请先部署 ${CloudConfig.ocrFunctionName} 云函数`;
              } else if (err.errMsg && err.errMsg.includes('not init')) {
                errorMsg = '云开发未初始化，请检查 utils/cloud-config.ts 配置';
              } else {
                errorMsg = err.errMsg || '识别失败，请重试';
              }
              
              // 创建一个包含错误信息的错误对象
              const error = new Error(errorMsg);
              (error as any).errCode = err.errCode;
              (error as any).errMsg = err.errMsg;
              reject(error);
            }
          });
        },
        fail: (err: any) => {
          console.error('图片上传失败:', err);
          
          let errorMsg = '图片上传失败，请重试';
          if (err.errCode === -601034 || 
              (err.errMsg && err.errMsg.includes('没有权限')) ||
              (err.errMsg && err.errMsg.includes('开通云开发'))) {
            errorMsg = '请先在微信小程序后台开通云开发，并在 utils/cloud-config.ts 中配置环境ID';
          }
          
          const error = new Error(errorMsg);
          (error as any).errCode = err.errCode;
          (error as any).errMsg = err.errMsg;
          reject(error);
        }
      });
    });
  },

  // 方案2：使用第三方OCR服务（需要API密钥，不推荐直接在前端使用）
  // 注意：此方案存在安全风险，API密钥会暴露在前端代码中
  // 如果必须使用，建议使用云函数作为中间层
  async recognizeWithThirdPartyOCR(filePath: string): Promise<any> {
    // 注意：此方法仅作为示例，实际使用需要：
    // 1. 将图片转换为base64
    // 2. 调用第三方OCR API（需要API密钥）
    // 3. 解析返回结果
    
    // 示例：使用腾讯云OCR（需要API密钥，不推荐直接在前端调用）
    // 建议：使用云函数封装此逻辑，保护API密钥
    
    return new Promise((_resolve, reject) => {
      // 读取图片文件
      const fs = wx.getFileSystemManager();
      fs.readFile({
        filePath: filePath,
        encoding: 'base64',
        success: () => {
          // 这里应该调用第三方OCR API
          // 但由于安全考虑，建议使用云函数
          reject(new Error('请使用云函数调用第三方OCR服务'));
        },
        fail: (err: any) => {
          reject(err);
        }
      });
    });
  },

  // 输入银行卡号
  onCardNumberInput(e: any) {
    let value = e.detail.value.replace(/\s/g, ''); // 移除空格
    // 每4位添加一个空格
    value = value.replace(/(.{4})/g, '$1 ').trim();
    this.setData({
      'formData.cardNumber': value
    });
  },

  // 输入持卡人姓名
  onCardHolderNameInput(e: any) {
    this.setData({
      'formData.cardHolderName': e.detail.value
    });
  },

  // 选择银行
  onBankChange(e: any) {
    const index = parseInt(e.detail.value);
    const bank = this.data.bankList[index];
    this.setData({
      bankIndex: index,
      'formData.bankName': bank.name,
      'formData.bankCode': bank.code
    });
  },

  // 选择卡类型
  selectCardType(e: any) {
    const type = parseInt(e.currentTarget.dataset.type);
    this.setData({
      'formData.cardType': type
    });
  },

  // 选择有效期
  onExpiryChange(e: any) {
    const date = e.detail.value; // 格式：YYYY-MM
    const [year, month] = date.split('-');
    const expiry = `${month}/${year.slice(-2)}`; // 转换为 MM/YY 格式
    this.setData({
      'formData.expiry': expiry
    });
  },

  // 输入身份证号
  onCardHolderIdcardInput(e: any) {
    let value = e.detail.value.replace(/\s/g, ''); // 移除空格
    this.setData({
      'formData.cardHolderIdcard': value
    });
  },

  // 输入预留手机号
  onCardHolderPhoneInput(e: any) {
    let value = e.detail.value.replace(/\s/g, ''); // 移除空格
    this.setData({
      'formData.cardHolderPhone': value
    });
  },

  // 输入开户支行
  onBranchNameInput(e: any) {
    this.setData({
      'formData.branchName': e.detail.value
    });
  },

  // 切换默认银行卡
  toggleDefault() {
    this.setData({
      'formData.setAsDefault': !this.data.formData.setAsDefault
    });
  },

  // 验证表单
  validateForm(): boolean {
    const { cardNumber, cardHolderName, cardHolderIdcard, cardHolderPhone, bankName, cardType } = this.data.formData;

    // 验证银行卡号
    const cardNumberClean = cardNumber.replace(/\s/g, '');
    if (!cardNumberClean || cardNumberClean.length < 16 || cardNumberClean.length > 19) {
      wx.showToast({
        title: '请输入正确的银行卡号（16-19位）',
        icon: 'none'
      });
      return false;
    }

    // 验证持卡人姓名
    if (!cardHolderName || cardHolderName.trim().length === 0) {
      wx.showToast({
        title: '请输入持卡人姓名',
        icon: 'none'
      });
      return false;
    }

    // 验证身份证号
    const idcardRegex = /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[0-9Xx]$/;
    if (!cardHolderIdcard || !idcardRegex.test(cardHolderIdcard)) {
      wx.showToast({
        title: '请输入正确的身份证号',
        icon: 'none'
      });
      return false;
    }

    // 验证手机号
    const phoneRegex = /^1[3-9]\d{9}$/;
    if (!cardHolderPhone || !phoneRegex.test(cardHolderPhone)) {
      wx.showToast({
        title: '请输入正确的预留手机号',
        icon: 'none'
      });
      return false;
    }

    // 验证银行名称
    if (!bankName) {
      wx.showToast({
        title: '请选择银行',
        icon: 'none'
      });
      return false;
    }

    // 验证卡类型
    if (!cardType || (cardType !== 1 && cardType !== 2 && cardType !== 3)) {
      wx.showToast({
        title: '请选择卡类型',
        icon: 'none'
      });
      return false;
    }

    return true;
  },

  // 提交表单
  async submitForm() {
    if (!this.validateForm()) {
      return;
    }

    this.setData({ submitting: true });
    wx.showLoading({ title: '提交中...', mask: true });

    try {
      const { formData } = this.data;
      // 移除卡号和身份证号中的空格
      const cardNumber = formData.cardNumber.replace(/\s/g, '');
      const cardHolderIdcard = formData.cardHolderIdcard.replace(/\s/g, '');
      const cardHolderPhone = formData.cardHolderPhone.replace(/\s/g, '');

      const params = {
        bankName: formData.bankName,
        bankCode: formData.bankCode || undefined,
        branchName: formData.branchName || undefined,
        cardNumber: cardNumber,
        cardHolderName: formData.cardHolderName.trim(),
        cardHolderIdcard: cardHolderIdcard,
        cardHolderPhone: cardHolderPhone,
        cardType: formData.cardType,
        setAsDefault: formData.setAsDefault || false
      };

      const res = await BankCardAPI.addBankCard(params);

      if (res.code === 200) {
        wx.showToast({
          title: '添加成功',
          icon: 'success'
        });

        setTimeout(() => {
          wx.navigateBack();
        }, 1500);
      } else {
        throw new Error(res.msg || '添加失败');
      }
    } catch (error: any) {
      console.error('添加银行卡失败:', error);
      wx.showToast({
        title: error.message || error.msg || '添加失败',
        icon: 'none',
        duration: 2000
      });
    } finally {
      this.setData({ submitting: false });
      wx.hideLoading();
    }
  }
});

